home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / wstools / c14n.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  9.4 KB  |  359 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. _copyright = 'Copyright 2001, Zolera Systems Inc.  All Rights Reserved.\nCopyright 2001, MIT. All Rights Reserved.\n\nDistributed under the terms of:\n  Python 2.0 License or later.\n  http://www.python.org/2.0.1/license.html\nor\n  W3C Software License\n  http://www.w3.org/Consortium/Legal/copyright-software-19980720\n'
  5. import string
  6. from xml.dom import Node
  7.  
  8. try:
  9.     from xml.ns import XMLNS
  10. except:
  11.     
  12.     class XMLNS:
  13.         BASE = 'http://www.w3.org/2000/xmlns/'
  14.         XML = 'http://www.w3.org/XML/1998/namespace'
  15.  
  16.  
  17.  
  18. try:
  19.     import cStringIO
  20.     StringIO = cStringIO
  21. except ImportError:
  22.     import StringIO
  23.  
  24.  
  25. _attrs = lambda E: if not E.attributes or E.attributes.values():
  26. pass[]
  27.  
  28. _children = lambda E: if not E.childNodes:
  29. pass[]
  30.  
  31. _IN_XML_NS = lambda n: n.name.startswith('xmlns')
  32.  
  33. _inclusive = lambda n: n.unsuppressedPrefixes == None
  34. (_LesserElement, _Element, _GreaterElement) = range(3)
  35.  
  36. def _sorter(n1, n2):
  37.     i = cmp(n1.namespaceURI, n2.namespaceURI)
  38.     if i:
  39.         return i
  40.     
  41.     return cmp(n1.localName, n2.localName)
  42.  
  43.  
  44. def _sorter_ns(n1, n2):
  45.     if n1[0] == 'xmlns':
  46.         return -1
  47.     
  48.     if n2[0] == 'xmlns':
  49.         return 1
  50.     
  51.     return cmp(n1[0], n2[0])
  52.  
  53.  
  54. def _utilized(n, node, other_attrs, unsuppressedPrefixes):
  55.     if n.startswith('xmlns:'):
  56.         n = n[6:]
  57.     elif n.startswith('xmlns'):
  58.         n = n[5:]
  59.     
  60.     if (n == '' or node.prefix in ('#default', None)) and n == node.prefix or n in unsuppressedPrefixes:
  61.         return 1
  62.     
  63.     for attr in other_attrs:
  64.         if n == attr.prefix:
  65.             return 1
  66.             continue
  67.     
  68.     if unsuppressedPrefixes is not None:
  69.         for attr in _attrs(node):
  70.             if n == attr.prefix:
  71.                 return 1
  72.                 continue
  73.         
  74.     
  75.     return 0
  76.  
  77.  
  78. def _inclusiveNamespacePrefixes(node, context, unsuppressedPrefixes):
  79.     inclusive = []
  80.     if node.prefix:
  81.         usedPrefixes = [
  82.             'xmlns:%s' % node.prefix]
  83.     else:
  84.         usedPrefixes = [
  85.             'xmlns']
  86.     for a in _attrs(node):
  87.         if a.nodeName.startswith('xmlns') or not (a.prefix):
  88.             continue
  89.         
  90.         usedPrefixes.append('xmlns:%s' % a.prefix)
  91.     
  92.     unused_namespace_dict = { }
  93.     for attr in context:
  94.         n = attr.nodeName
  95.         if n in unsuppressedPrefixes:
  96.             inclusive.append(attr)
  97.             continue
  98.         if n.startswith('xmlns:') and n[6:] in unsuppressedPrefixes:
  99.             inclusive.append(attr)
  100.             continue
  101.         if n.startswith('xmlns') and n[5:] in unsuppressedPrefixes:
  102.             inclusive.append(attr)
  103.             continue
  104.         if attr.nodeName in usedPrefixes:
  105.             inclusive.append(attr)
  106.             continue
  107.         if n.startswith('xmlns:'):
  108.             unused_namespace_dict[n] = attr.value
  109.             continue
  110.     
  111.     return (inclusive, unused_namespace_dict)
  112.  
  113.  
  114. _in_subset = lambda subset, node: if not subset is None:
  115. passnode in subset
  116.  
  117. class _implementation:
  118.     handlers = { }
  119.     
  120.     def __init__(self, node, write, **kw):
  121.         self.write = write
  122.         self.subset = kw.get('subset')
  123.         self.comments = kw.get('comments', 0)
  124.         self.unsuppressedPrefixes = kw.get('unsuppressedPrefixes')
  125.         nsdict = kw.get('nsdict', {
  126.             'xml': XMLNS.XML,
  127.             'xmlns': XMLNS.BASE })
  128.         self.state = (nsdict, {
  129.             'xml': '' }, { }, { })
  130.         if node.nodeType == Node.DOCUMENT_NODE:
  131.             self._do_document(node)
  132.         elif node.nodeType == Node.ELEMENT_NODE:
  133.             self.documentOrder = _Element
  134.             if not _inclusive(self):
  135.                 (inherited, unused) = _inclusiveNamespacePrefixes(node, self._inherit_context(node), self.unsuppressedPrefixes)
  136.                 self._do_element(node, inherited, unused = unused)
  137.             else:
  138.                 inherited = self._inherit_context(node)
  139.                 self._do_element(node, inherited)
  140.         elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
  141.             pass
  142.         else:
  143.             raise TypeError, str(node)
  144.  
  145.     
  146.     def _inherit_context(self, node):
  147.         xmlattrs = filter(_IN_XML_NS, _attrs(node))
  148.         inherited = []
  149.         parent = node.parentNode
  150.         while parent and parent.nodeType == Node.ELEMENT_NODE:
  151.             for a in filter(_IN_XML_NS, _attrs(parent)):
  152.                 n = a.localName
  153.                 if n not in xmlattrs:
  154.                     xmlattrs.append(n)
  155.                     inherited.append(a)
  156.                     continue
  157.             
  158.             parent = parent.parentNode
  159.         return inherited
  160.  
  161.     
  162.     def _do_document(self, node):
  163.         self.documentOrder = _LesserElement
  164.         for child in node.childNodes:
  165.             if child.nodeType == Node.ELEMENT_NODE:
  166.                 self.documentOrder = _Element
  167.                 self._do_element(child)
  168.                 self.documentOrder = _GreaterElement
  169.                 continue
  170.             if child.nodeType == Node.PROCESSING_INSTRUCTION_NODE:
  171.                 self._do_pi(child)
  172.                 continue
  173.             if child.nodeType == Node.COMMENT_NODE:
  174.                 self._do_comment(child)
  175.                 continue
  176.             if child.nodeType == Node.DOCUMENT_TYPE_NODE:
  177.                 continue
  178.             raise TypeError, str(child)
  179.         
  180.  
  181.     handlers[Node.DOCUMENT_NODE] = _do_document
  182.     
  183.     def _do_text(self, node):
  184.         if not _in_subset(self.subset, node):
  185.             return None
  186.         
  187.         s = string.replace(node.data, '&', '&')
  188.         s = string.replace(s, '<', '<')
  189.         s = string.replace(s, '>', '>')
  190.         s = string.replace(s, '\r', ' ')
  191.         if s:
  192.             self.write(s)
  193.         
  194.  
  195.     handlers[Node.TEXT_NODE] = _do_text
  196.     handlers[Node.CDATA_SECTION_NODE] = _do_text
  197.     
  198.     def _do_pi(self, node):
  199.         if not _in_subset(self.subset, node):
  200.             return None
  201.         
  202.         W = self.write
  203.         if self.documentOrder == _GreaterElement:
  204.             W('\n')
  205.         
  206.         W('<?')
  207.         W(node.nodeName)
  208.         s = node.data
  209.         if s:
  210.             W(' ')
  211.             W(s)
  212.         
  213.         W('?>')
  214.         if self.documentOrder == _LesserElement:
  215.             W('\n')
  216.         
  217.  
  218.     handlers[Node.PROCESSING_INSTRUCTION_NODE] = _do_pi
  219.     
  220.     def _do_comment(self, node):
  221.         if not _in_subset(self.subset, node):
  222.             return None
  223.         
  224.         if self.comments:
  225.             W = self.write
  226.             if self.documentOrder == _GreaterElement:
  227.                 W('\n')
  228.             
  229.             W('<!--')
  230.             W(node.data)
  231.             W('-->')
  232.             if self.documentOrder == _LesserElement:
  233.                 W('\n')
  234.             
  235.         
  236.  
  237.     handlers[Node.COMMENT_NODE] = _do_comment
  238.     
  239.     def _do_attr(self, n, value):
  240.         W = self.write
  241.         W(' ')
  242.         W(n)
  243.         W('="')
  244.         s = string.replace(value, '&', '&')
  245.         s = string.replace(s, '<', '<')
  246.         s = string.replace(s, '"', '"')
  247.         s = string.replace(s, '\t', ' ')
  248.         s = string.replace(s, '\n', ' ')
  249.         s = string.replace(s, '\r', ' ')
  250.         W(s)
  251.         W('"')
  252.  
  253.     
  254.     def _do_element(self, node, initial_other_attrs = [], unused = None):
  255.         ns_parent = self.state[0]
  256.         ns_rendered = self.state[1].copy()
  257.         xml_attrs = self.state[2].copy()
  258.         ns_unused_inherited = unused
  259.         if unused is None:
  260.             ns_unused_inherited = self.state[3].copy()
  261.         
  262.         ns_local = ns_parent.copy()
  263.         inclusive = _inclusive(self)
  264.         xml_attrs_local = { }
  265.         other_attrs = []
  266.         in_subset = _in_subset(self.subset, node)
  267.         for a in initial_other_attrs + _attrs(node):
  268.             if a.namespaceURI == XMLNS.BASE:
  269.                 n = a.nodeName
  270.                 if n == 'xmlns:':
  271.                     n = 'xmlns'
  272.                 
  273.                 ns_local[n] = a.nodeValue
  274.             elif a.namespaceURI == XMLNS.XML:
  275.                 if (inclusive or in_subset) and _in_subset(self.subset, a):
  276.                     xml_attrs_local[a.nodeName] = a
  277.                 
  278.             elif _in_subset(self.subset, a):
  279.                 other_attrs.append(a)
  280.             
  281.             xml_attrs.update(xml_attrs_local)
  282.         
  283.         W = self.write
  284.         name = None
  285.         if in_subset:
  286.             name = node.nodeName
  287.             if not inclusive:
  288.                 if node.prefix is not None:
  289.                     prefix = 'xmlns:%s' % node.prefix
  290.                 else:
  291.                     prefix = 'xmlns'
  292.                 if not ns_rendered.has_key(prefix) and not ns_local.has_key(prefix):
  293.                     if not ns_unused_inherited.has_key(prefix):
  294.                         raise RuntimeError, 'For exclusive c14n, unable to map prefix "%s" in %s' % (prefix, node)
  295.                     
  296.                     ns_local[prefix] = ns_unused_inherited[prefix]
  297.                     del ns_unused_inherited[prefix]
  298.                 
  299.             
  300.             W('<')
  301.             W(name)
  302.             ns_to_render = []
  303.             for n, v in ns_local.items():
  304.                 if n == 'xmlns' and v in [
  305.                     XMLNS.BASE,
  306.                     ''] and ns_rendered.get('xmlns') in [
  307.                     XMLNS.BASE,
  308.                     '',
  309.                     None]:
  310.                     continue
  311.                 
  312.                 if n in ('xmlns:xml', 'xml') and v in ('http://www.w3.org/XML/1998/namespace',):
  313.                     continue
  314.                 
  315.                 if (n, v) not in ns_rendered.items():
  316.                     if inclusive or _utilized(n, node, other_attrs, self.unsuppressedPrefixes):
  317.                         ns_to_render.append((n, v))
  318.                     elif not inclusive:
  319.                         ns_unused_inherited[n] = v
  320.                     
  321.                 _utilized(n, node, other_attrs, self.unsuppressedPrefixes)
  322.             
  323.             ns_to_render.sort(_sorter_ns)
  324.             for n, v in ns_to_render:
  325.                 self._do_attr(n, v)
  326.                 ns_rendered[n] = v
  327.             
  328.             if not inclusive or _in_subset(self.subset, node.parentNode):
  329.                 other_attrs.extend(xml_attrs_local.values())
  330.             else:
  331.                 other_attrs.extend(xml_attrs.values())
  332.             other_attrs.sort(_sorter)
  333.             for a in other_attrs:
  334.                 self._do_attr(a.nodeName, a.value)
  335.             
  336.             W('>')
  337.         
  338.         state = self.state
  339.         self.state = (ns_local, ns_rendered, xml_attrs, ns_unused_inherited)
  340.         for c in _children(node):
  341.             _implementation.handlers[c.nodeType](self, c)
  342.         
  343.         self.state = state
  344.         if name:
  345.             W('</%s>' % name)
  346.         
  347.  
  348.     handlers[Node.ELEMENT_NODE] = _do_element
  349.  
  350.  
  351. def Canonicalize(node, output = None, **kw):
  352.     if output:
  353.         apply(_implementation, (node, output.write), kw)
  354.     else:
  355.         s = StringIO.StringIO()
  356.         apply(_implementation, (node, s.write), kw)
  357.         return s.getvalue()
  358.  
  359.